﻿#include <iostream>
#include <assert.h>
using namespace std;

//
//int main()
//{
//	int a[5] = { 1, 2, 3, 4, 5 };
//	int* ptr = (int*)(&a + 1);
//	printf("%d,%d", *(a + 1), *(ptr - 1));
//	return 0;
//}
//struct Test
//{
//	int Num;
//	char* pcName;
//	short sDate;
//	char cha[2];
//	short sBa[4];
//}*p;
//int main()
//{
//	printf("%p\n", p + 0x1);
//	printf("%p\n", (unsigned long)p + 0x1);
//	printf("%p\n", (unsigned int*)p + 0x1);
//	return 0;
//}


//int main()
//{
//	int a[4] = { 1, 2, 3, 4 };
//	int* ptr1 = (int*)(&a + 1);
//	int* ptr2 = (int*)((int)a + 1);
//	printf("%x,%x", ptr1[-1], *ptr2);
//	return 0;
//}


//#include <stdio.h>
//int main()
//{
//	int a[3][2] = { (0, 1), (2, 3), (4, 5) };
//	int* p;
//	p = a[0];
//	printf("%d", p[0]);
//	return 0;
//}
//int main()
//{
//	int a[5][5];
//	int(*p)[4];
//	p = a;
//	printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
//	return 0;
//}

//int main()
//{
//	int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
//	int* ptr1 = (int*)(&aa + 1);
//	int* ptr2 = (int*)(*(aa + 1));
//	printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1));
//	return 0;
//}
//
//
//#include <stdio.h>
//int main()
//{
//	char* a[] = { "work","at","alibaba" };
//	char** pa = a;
//	pa++;
//	printf("%s\n", *pa);
//	return 0;
//}



//struct S1
//{
//	double d;
//	char c;
//	int i;
//};
//union Un1
//{
//	char c[5];
//	int i;
//};
//union Un2
//{
//	short c[7];
//	int i;
//};

void* mymemove(void* dst, void* src, size_t count)
{
	void* ret = dst;
	assert(dst);
	assert(src);
	if (src > dst)
	{
		while (count--)
		{
			*(char*)dst = *(char*)src;
			dst = (char*)dst + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		char* s1 = (char*)dst;
		char* s2 = (char*)src;
		s1 += count - 1;
		s2 += count - 1;
		while (count--)
		{
			*s1-- = *s2--;
		}
	}
	return ret;
}

void* mymemcpy(void* dst, void* src, size_t count)
{
	void* ret = dst;
	assert(dst);
	assert(src);

	while (count--)
	{
		*(char*)dst = *(char*)src;
		dst = (char*)dst + 1;
		src = (char*)src + 1;
	}
	return ret;
}

char* mystrstr(const char* str1, const char* str2)
{
	if (!*str2 )
		return (char*)str1;
	char* cp = (char*)str1;
	char* s1, *s2;
	while (*cp)
	{
		s1 = cp;
		s2 = (char*)str2;
		while (*s1 && *s2 &&!(*s1 - *s2))
		{
			s1++;
			s2++;
		}
		if (!*s2)
			return cp;
		cp++;
	}
	return NULL;
}

union Un
{
	char c;
	int i;
};
union Un1
{
	char c[5];
	int i;
};
//int main()
//{
//	int str1[] = { 1,2,3,4,5,6,7,8,9 };
//
//	mymemove(str1 + 2, str1,20);
//	/*for (int i = 0; i < sizeof(str1)/sizeof(str1[0]); i++)
//	{
//		cout << str1[i] << " ";
//	}*/
//	cout << sizeof(i) << endl;
//	return 0;
//}
// 


#include <stdio.h>  

int check_endianness() {
	unsigned int num = 0x1; // 选择一个只有一个字节为1的数，例如0x00000001  
	char* byte = (char*)&num; // 将num的地址转换为char*，以便访问其第一个字节  

	// 如果*byte为1，则表示机器是小端存储，因为最低有效字节存储在最低地址  
	// 如果*byte为0，则表示机器是大端存储，因为最高有效字节（在这个例子中是唯一的非零字节）存储在更高地址  
	return *byte;
}

//int main() {
//	if (check_endianness()) {
//		printf("The machine is Little-endian.\n");
//	}
//	else {
//		printf("The machine is Big-endian.\n");
//	}
//	return 0;
//}

char* Mystrstr(const char* str1, const char* str2)
{
	if (!*str2)
		return (char*)str1;

	char* cp =(char*)str1;
	char* s1, * s2;

	while (*cp)
	{
		s1 = cp;
		s2 = (char*)str2;
		while (*s1 && *s2 && !(*s1 - *s2))
		{
			s1++;
			s2++;
		}
		if (!*s2)
			return cp;
		cp++;
	}
	return NULL;
}



//#include <stdio.h>
//int main()
//{
//	char a = -1;
//	signed char b = -1;
//	unsigned char c = -1;
//	printf("a=%d,b=%d,c=%d", a, b, c);
//	return 0;
//}


#include <stdio.h>
//int main()
//{
//
//	unsigned int i;
//	for (i = 9; i >= 0; i--)
//	{
//		printf("%u\n", i);
//	}
//	return 0;
//}
/*

int main()
{
	int n = 9;
	float* pFloat = (float*)&n;
	printf("n的值为：%d\n", n);
	printf("*pFloat的值为：%f\n", *pFloat);
	*pFloat = 9.0;
	printf("num的值为：%d\n", n);
	printf("*pFloat的值为：%f\n", *pFloat);
	return 0;
}*/



//// 类中既有成员变量，又有成员函数
//class A1 {
//public:
//	void f1() {}
//private:
//	int _a;
//};
//class A2 {
//public:
//	void f2() {}
//};
//// 类中什么都没有---空类
//class A3
//{};
//
//
//int main()
//{
//	cout << sizeof(A1) << " " << sizeof(A2) << " " << sizeof(A3) << endl;
//	return 0 ;
//}




//// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
//class A
//{
//public:
//	void Print()
//	{
//		cout << "Print()" << endl;
//	}
//private:
//	int _a;
//};
//int main()
//{
//	A* p = nullptr;
//	p->Print();
//	return 0;
//}
 //1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
//class A
//{
//public:
//	void PrintA()
//	{
//		cout << _a << endl;
//	}
//private:
//	int _a;
//};
//int main()
//{
//	A* p = nullptr;
//	p->PrintA();
//	return 0;
//}



class Date
{
public:
	/*Date()
	{
		_year = 1900;
		_month = 1;
		_day = 1;
	}*/
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
// 以下测试函数能通过编译吗？
void Test()
{
	Date d1;
}


//int main()
//{
//	const int& a = 10;
//	return 0; 
//}

//
//void Fun(int& x) { cout << "左值引用" << endl; }
//void Fun(const int& x) { cout << "const 左值引用" << endl; }
//void Fun(int&& x) { cout << "右值引用" << endl; }
//void Fun(const int&& x) { cout << "const 右值引用" << endl; }
//// 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
//// 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，
//// 但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，
//// 我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发
//template<typename T>
//void PerfectForward(T&& t)
//{
//	Fun(t);
//}
//int main()
//{
//	PerfectForward(10);// 右值
//	int a;
//	PerfectForward(a);// 左值
//	PerfectForward(std::move(a)); // 右值
//	const int b = 8;
//	PerfectForward(b);// const 左值
//	PerfectForward(std::move(b)); // const 右值
//	return 0;
//}



#include <chrono>
#include <functional>
#include <future>
#include <iostream>
#include <string>

//#include <chrono>
//#include <functional>
//#include <future>
//#include <iostream>
//#include <string>
//
//class A {
//public:
//	A() {
//		std::cout << "A() \n";
//	}
//
//	~A() {
//		std::cout << "~A() \n";
//	}
//
//	A(const A& a) {
//		count_ = a.count_;
//		std::cout << "A copy \n";
//	}
//
//	A& operator=(const A& a) {
//		count_ = a.count_;
//		std::cout << "A = \n";
//		return *this;
//	}
//
//	A(A&& a) {
//		count_ = std::move(a.count_);
//		std::cout << "A move \n";
//	}
//
//	A& operator=(A&& a) {
//		count_ = std::move(a.count_);
//		std::cout << "A move = \n";
//		return *this;
//	}
//
//	std::string count_;
//};
//
//
//int main() {
//	A a;
//	a.count_ = "12345";
//	A b = std::move(a);
//	std::cout << a.count_ << std::endl;
//	std::cout << b.count_ << std::endl;
//	return 0;
//}



struct ListNode
{
	int _data;
	shared_ptr<ListNode> _prev;
	shared_ptr<ListNode> _next;
	~ListNode() { cout << "~ListNode()" << endl; }
};
int main()
{
	shared_ptr<ListNode> node1(new ListNode);
	shared_ptr<ListNode> node2(new ListNode);
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	node1->_next = node2;
	node2->_prev = node1;
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	return 0;
}